package config

import (
	"flag"
	"fmt"
)

// Args 命令行参数结构体
// 示例值: mirror="https://mirrors.aliyun.com/openssh/portable/"
type Args struct {
	Mirror         string // 镜像源URL
	InstallDir     string // 安装目录
	DownloadDir    string // 下载目录
	LogDir         string // 日志目录
	UpgradeTime    string // 升级时间段
	RootLogin      string // root登录配置
	KeyOnlyLogin   string // 仅密钥登录配置
	CheckInterval  int    // 检测间隔时间(小时)
	Force          bool   // 强制升级标志
	Service        bool   // 服务注册标志
	SkipTLSVerify  bool   // 跳过HTTPS证书检测
}

// 默认参数常量
const (
	DefaultMirror         = "https://mirrors.aliyun.com/openssh/portable/"        // 默认镜像源URL
	DefaultInstallDir     = "/usr/local/openssh"                                 // 默认安装目录
	DefaultDownloadDir    = "/tmp/ssh-upgrade"                                    // 默认下载目录
	DefaultLogDir         = "/var/log/ssh-auto-upgrade"                          // 默认日志目录
	DefaultUpgradeTime    = "00:00:00-08:00:00"                                   // 默认升级时间段
	DefaultRootLogin      = "auto"                                                // 默认root登录配置
	DefaultKeyOnlyLogin   = "auto"                                                // 默认仅密钥登录配置
	DefaultCheckInterval  = 1                                                     // 默认检测间隔时间
	DefaultForce          = false                                                 // 默认强制升级标志
	DefaultService        = false                                                 // 默认服务注册标志
	DefaultSkipTLSVerify  = false                                                 // 默认跳过HTTPS证书检测
)

// ParseArgs 解析命令行参数
// 示例值: 无参数
func ParseArgs() *Args {
	args := &Args{}

	// 定义命令行参数
	flag.StringVar(&args.Mirror, "mirror", DefaultMirror, "OpenSSH镜像源URL")
	flag.StringVar(&args.Mirror, "m", DefaultMirror, "OpenSSH镜像源URL(简写)")
	
	flag.StringVar(&args.InstallDir, "install-dir", DefaultInstallDir, "OpenSSH安装目录")
	flag.StringVar(&args.InstallDir, "i", DefaultInstallDir, "OpenSSH安装目录(简写)")
	
	flag.StringVar(&args.DownloadDir, "download-dir", DefaultDownloadDir, "下载目录")
	flag.StringVar(&args.DownloadDir, "d", DefaultDownloadDir, "下载目录(简写)")
	
	flag.StringVar(&args.LogDir, "log-dir", DefaultLogDir, "日志目录")
	flag.StringVar(&args.LogDir, "l", DefaultLogDir, "日志目录(简写)")
	
	flag.StringVar(&args.UpgradeTime, "upgrade-time", DefaultUpgradeTime, "升级时间段，格式为 HH:MM:SS-HH:MM:SS")
	flag.StringVar(&args.UpgradeTime, "t", DefaultUpgradeTime, "升级时间段(简写)")
	
	flag.StringVar(&args.RootLogin, "root-login", DefaultRootLogin, "root登录配置: auto(智能检测), yes(启用), no(禁用)")
	flag.StringVar(&args.RootLogin, "rl", DefaultRootLogin, "root登录配置(简写)")
	
	flag.StringVar(&args.KeyOnlyLogin, "key-only-login", DefaultKeyOnlyLogin, "仅密钥登录配置: auto(智能检测), yes(启用), no(禁用)")
	flag.StringVar(&args.KeyOnlyLogin, "kl", DefaultKeyOnlyLogin, "仅密钥登录配置(简写)")
	
	flag.IntVar(&args.CheckInterval, "check-interval", DefaultCheckInterval, "检测间隔时间，单位小时")
	flag.IntVar(&args.CheckInterval, "interval", DefaultCheckInterval, "检测间隔时间(简写)")
	
	flag.BoolVar(&args.Force, "force", DefaultForce, "强制升级，即使版本相同也执行安装")
	flag.BoolVar(&args.Force, "f", DefaultForce, "强制升级(简写)")
	
	flag.BoolVar(&args.Service, "service", DefaultService, "注册为systemd服务")
	flag.BoolVar(&args.Service, "s", DefaultService, "注册为systemd服务(简写)")

	flag.BoolVar(&args.SkipTLSVerify, "skip-tls-verify", DefaultSkipTLSVerify, "跳过HTTPS证书检测，适用于内网环境")
	flag.BoolVar(&args.SkipTLSVerify, "stv", DefaultSkipTLSVerify, "跳过HTTPS证书检测(简写)")

	// 解析参数
	flag.Parse()

	// 验证参数
	if err := args.Validate(); err != nil {
		fmt.Printf("参数验证失败: %v\n", err)
		flag.Usage()
		return nil
	}

	return args
}

// Validate 验证参数有效性
// 示例值: args.Mirror="https://mirrors.aliyun.com/openssh/portable/"
func (a *Args) Validate() error {
	// 验证镜像URL格式
	if a.Mirror == "" {
		return fmt.Errorf("镜像URL不能为空")
	}

	// 验证升级时间段格式
	if err := validateTimeRange(a.UpgradeTime); err != nil {
		return fmt.Errorf("升级时间段格式无效: %v", err)
	}

	// 验证root登录配置
	if a.RootLogin != "auto" && a.RootLogin != "yes" && a.RootLogin != "no" {
		return fmt.Errorf("root登录配置必须是auto、yes或no")
	}

	// 验证仅密钥登录配置
	if a.KeyOnlyLogin != "auto" && a.KeyOnlyLogin != "yes" && a.KeyOnlyLogin != "no" {
		return fmt.Errorf("仅密钥登录配置必须是auto、yes或no")
	}

	// 验证检测间隔时间
	if a.CheckInterval < 1 || a.CheckInterval > 48 {
		return fmt.Errorf("检测间隔时间必须在1-48小时之间")
	}

	return nil
}

// validateTimeRange 验证时间段格式
// 示例值: timeRange="00:00:00-08:00:00"
func validateTimeRange(timeRange string) error {
	if timeRange == "" {
		return fmt.Errorf("时间段不能为空")
	}
	
	// 简单的格式验证，实际的时间有效性检查在time模块中
	if len(timeRange) != 17 || timeRange[8] != '-' {
		return fmt.Errorf("时间段格式必须为HH:MM:SS-HH:MM:SS")
	}
	
	return nil
}

// GetCommandArgs 获取命令行参数字符串
// 示例值: args.Mirror="https://mirrors.aliyun.com/openssh/portable/"
func (a *Args) GetCommandArgs() string {
	args := ""
	
	// 只添加与默认值不同的参数
	if a.Mirror != DefaultMirror {
		args += fmt.Sprintf(" -m %s", a.Mirror)
	}
	if a.InstallDir != DefaultInstallDir {
		args += fmt.Sprintf(" -i %s", a.InstallDir)
	}
	if a.DownloadDir != DefaultDownloadDir {
		args += fmt.Sprintf(" -d %s", a.DownloadDir)
	}
	if a.LogDir != DefaultLogDir {
		args += fmt.Sprintf(" -l %s", a.LogDir)
	}
	if a.UpgradeTime != DefaultUpgradeTime {
		args += fmt.Sprintf(" -t %s", a.UpgradeTime)
	}
	if a.RootLogin != DefaultRootLogin {
		args += fmt.Sprintf(" -rl %s", a.RootLogin)
	}
	if a.KeyOnlyLogin != DefaultKeyOnlyLogin {
		args += fmt.Sprintf(" -kl %s", a.KeyOnlyLogin)
	}
	if a.CheckInterval != DefaultCheckInterval {
		args += fmt.Sprintf(" --interval %d", a.CheckInterval)
	}
	if a.Force != DefaultForce {
		args += " -f"
	}
	if a.SkipTLSVerify != DefaultSkipTLSVerify {
		args += " -stv"
	}
	
	return args
}